package org.jeecg.common.util;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.sql.DataSource;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.common.constant.DataBaseConstant;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.util.oss.OssBootUtil;
import org.jeecgframework.poi.util.PoiPublicUtil;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.multipart.MultipartFile;

@Slf4j
public class CommonUtils {

  // 中文正则
  private static Pattern ZHONGWEN_PATTERN = Pattern.compile("[\u4e00-\u9fa5]");

  public static String uploadOnlineImage(
      byte[] data, String basePath, String bizPath, String uploadType) {
    String dbPath = null;
    String fileName = "image" + Math.round(Math.random() * 100000000000L);
    fileName += "." + PoiPublicUtil.getFileExtendName(data);
    try {
      if (CommonConstant.UPLOAD_TYPE_LOCAL.equals(uploadType)) {
        File file = new File(basePath + File.separator + bizPath + File.separator);
        if (!file.exists()) {
          file.mkdirs(); // 创建文件根目录
        }
        String savePath = file.getPath() + File.separator + fileName;
        File savefile = new File(savePath);
        FileCopyUtils.copy(data, savefile);
        dbPath = bizPath + File.separator + fileName;
      } else {
        InputStream in = new ByteArrayInputStream(data);
        String relativePath = bizPath + "/" + fileName;
        if (CommonConstant.UPLOAD_TYPE_MINIO.equals(uploadType)) {
          dbPath = MinioUtil.upload(in, relativePath);
        } else if (CommonConstant.UPLOAD_TYPE_OSS.equals(uploadType)) {
          dbPath = OssBootUtil.upload(in, relativePath);
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
    return dbPath;
  }

  /**
   * 判断文件名是否带盘符，重新处理
   *
   * @param fileName
   * @return
   */
  public static String getFileName(String fileName) {
    // 判断是否带有盘符信息
    // Check for Unix-style path
    int unixSep = fileName.lastIndexOf('/');
    // Check for Windows-style path
    int winSep = fileName.lastIndexOf('\\');
    // Cut off at latest possible point
    int pos = (winSep > unixSep ? winSep : unixSep);
    if (pos != -1) {
      // Any sort of path separator found...
      fileName = fileName.substring(pos + 1);
    }
    // 替换上传文件名字的特殊字符
    fileName = fileName.replace("=", "").replace(",", "").replace("&", "").replace("#", "");
    // 替换上传文件名字中的空格
    fileName = fileName.replaceAll("\\s", "");
    return fileName;
  }

  // java 判断字符串里是否包含中文字符
  public static boolean ifContainChinese(String str) {
    if (str.getBytes().length == str.length()) {
      return false;
    } else {
      Matcher m = ZHONGWEN_PATTERN.matcher(str);
      if (m.find()) {
        return true;
      }
      return false;
    }
  }

  /** 统一全局上传 @Return: java.lang.String */
  public static String upload(MultipartFile file, String bizPath, String uploadType) {
    String url = "";
    if (CommonConstant.UPLOAD_TYPE_MINIO.equals(uploadType)) {
      url = MinioUtil.upload(file, bizPath);
    } else {
      url = OssBootUtil.upload(file, bizPath);
    }
    return url;
  }

  /** 统一全局上传 带桶 @Return: java.lang.String */
  public static String upload(
      MultipartFile file, String bizPath, String uploadType, String customBucket) {
    String url = "";
    if (CommonConstant.UPLOAD_TYPE_MINIO.equals(uploadType)) {
      url = MinioUtil.upload(file, bizPath, customBucket);
    } else {
      url = OssBootUtil.upload(file, bizPath, customBucket);
    }
    return url;
  }

  /** 当前系统数据库类型 */
  private static String DB_TYPE = "";

  public static String getDatabaseType() {
    if (oConvertUtils.isNotEmpty(DB_TYPE)) {
      return DB_TYPE;
    }
    DataSource dataSource = SpringContextUtils.getApplicationContext().getBean(DataSource.class);
    try {
      return getDatabaseTypeByDataSource(dataSource);
    } catch (SQLException e) {
      // e.printStackTrace();
      log.warn(e.getMessage());
      return "";
    }
  }

  /**
   * 获取数据库类型
   *
   * @param dataSource
   * @return
   * @throws SQLException
   */
  private static String getDatabaseTypeByDataSource(DataSource dataSource) throws SQLException {
    if ("".equals(DB_TYPE)) {
      Connection connection = dataSource.getConnection();
      try {
        DatabaseMetaData md = connection.getMetaData();
        String dbType = md.getDatabaseProductName().toLowerCase();
        if (dbType.indexOf("mysql") >= 0) {
          DB_TYPE = DataBaseConstant.DB_TYPE_MYSQL;
        } else if (dbType.indexOf("oracle") >= 0 || dbType.indexOf("dm") >= 0) {
          DB_TYPE = DataBaseConstant.DB_TYPE_ORACLE;
        } else if (dbType.indexOf("sqlserver") >= 0 || dbType.indexOf("sql server") >= 0) {
          DB_TYPE = DataBaseConstant.DB_TYPE_SQLSERVER;
        } else if (dbType.indexOf("postgresql") >= 0) {
          DB_TYPE = DataBaseConstant.DB_TYPE_POSTGRESQL;
        } else {
          throw new JeecgBootException("数据库类型:[" + dbType + "]不识别!");
        }
      } catch (Exception e) {
        log.error(e.getMessage(), e);
      } finally {
        connection.close();
      }
    }
    return DB_TYPE;
  }
}
